{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d1fd984b",
   "metadata": {},
   "source": [
    "# 引言\n",
    "1. 什么是线性回归？【一次函数、直线】\n",
    "线性：两直线之间是一次函数，对应的图像是直线。\n",
    "非线性：两直线之间不是一次函数，对应的图像不是直线\n",
    "\n",
    "\n",
    "2. 分类和回归？\n",
    "**在监督学习中，**\n",
    "分类：如果预测的变量是离散的，我们称其为分类（如决策树等）\n",
    "连续：如果预测的变量是连续的，我们称其为回归。\n",
    "\n",
    "3. 回归的由来？\n",
    "回归是指人们在测量失误的时候因为客观条件所限，求得的都是测量值而不是事物的真实值，\n",
    "为了得到真实值，无限次地进行测量，\n",
    "最后通过这些测量数据计算回归到真实值，这就是回归的由来。\n",
    "\n",
    "**线性回归就是要找一条直线，并且让这条直线尽可能地拟合图中的数据点**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ff7df4d",
   "metadata": {},
   "source": [
    "<img src='img/回归分析自变量数量.jpg' width='400px' />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ad03394",
   "metadata": {},
   "source": [
    "**最小二乘法**\n",
    "\n",
    "<img src='img/总离差.jpg' width='400px' />\n",
    "\n",
    "作为总离差，并使之达到最小。这样回归直线就是所有直线中 Q 取值最小的那一条。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "616fffe2",
   "metadata": {},
   "source": [
    "**梯度下降法**\n",
    "\n",
    "* 我们想要让这个方程拟合得非常好，那么就要是误差尽量小，评价误差小的方法就是所有误差的平方和最小，计算误差平方和最小的方法除了**最小二乘法**，还有一种方法叫**梯度下降法**。\n",
    "\n",
    "\n",
    "* 梯度下降（Gradient Descent）在机器学习中应用非常广泛。\n",
    "\n",
    "\n",
    "* 它的主要目的是通过迭代找到目标函数的最小值，想办法使真实值和预测值之间的差异越小越好。\n",
    "\n",
    "\n",
    "* 我们的目标就是找到这个代价函数的最小值。这个函数可以是**均方误差代价函数**（平方误差代价函数）。\n",
    "\n",
    "<img src='img/平方误差代价函数.jpg' width='400px' />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac7202fe",
   "metadata": {},
   "source": [
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45643f95",
   "metadata": {},
   "source": [
    "# 1. 线性回归"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d715119a",
   "metadata": {},
   "source": [
    "举例子：用梯度下降算法拟合直线。\n",
    "步骤：\n",
    "1. 定义一个代价函数——均方误差代价函数\n",
    "\n",
    "    （1）m：  数据点的个数 ，样本数。\n",
    "    \n",
    "    （2）1/2：是一个常量，这样是为了在求梯度的手，二次方乘下来的 2 就和这里的 1/2 抵消了，自然就没有多余的常数系数了，以便后续的计算，同时对计算结果没有影响。\n",
    "    \n",
    "    （3）y ： 是数据集中每个点的真实 y 坐标的值，也就是类标签。\n",
    "    \n",
    "    （4）h：  是我们的预测函数（假设函数），根据每一个输入 x ， 根据 ${\\theta}$  计算得到的预测的 y 值。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d8b6451d",
   "metadata": {},
   "source": [
    "        从代价函数中可以看到，代价函数中的变量有两个，所以是一个多变量的梯度下降问题，求解出代价函数的梯度，也就是分别对两个变量进行微分。\n",
    "        \n",
    "**为了方便代码的编写，我们会将所有公式都转换为矩阵的形式。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "02614ea6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c0e7d8a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  1.],\n",
       "       [ 1.,  2.],\n",
       "       [ 1.,  3.],\n",
       "       [ 1.,  4.],\n",
       "       [ 1.,  5.],\n",
       "       [ 1.,  6.],\n",
       "       [ 1.,  7.],\n",
       "       [ 1.,  8.],\n",
       "       [ 1.,  9.],\n",
       "       [ 1., 10.],\n",
       "       [ 1., 11.],\n",
       "       [ 1., 12.],\n",
       "       [ 1., 13.],\n",
       "       [ 1., 14.],\n",
       "       [ 1., 15.],\n",
       "       [ 1., 16.],\n",
       "       [ 1., 17.],\n",
       "       [ 1., 18.],\n",
       "       [ 1., 19.],\n",
       "       [ 1., 20.]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 我们需要定义数据集和学习率\n",
    "# 数据集大小，即 20 个数据点\n",
    "m = 20\n",
    "\n",
    "# x 坐标以及对应的矩阵\n",
    "X0 = ones((m,1))      #生成 m 行 1 列的向量作为 x0 ,全是1\n",
    "X1 = arange(1,m+1).reshape(m,1)    # 生成一个 m 行 1 列的向量，也就是 x1，从 1 到 m\n",
    "X = hstack((X0,X1))\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "26d9eaf5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3],\n",
       "       [ 4],\n",
       "       [ 5],\n",
       "       [ 5],\n",
       "       [ 2],\n",
       "       [ 4],\n",
       "       [ 7],\n",
       "       [ 8],\n",
       "       [11],\n",
       "       [ 8],\n",
       "       [12],\n",
       "       [11],\n",
       "       [13],\n",
       "       [13],\n",
       "       [16],\n",
       "       [17],\n",
       "       [18],\n",
       "       [17],\n",
       "       [19],\n",
       "       [21]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 对应的 y 坐标 .reshape(-1,1) 或 .reshape(m,1) 都可以\n",
    "Y = array([\n",
    "    3,4,5,5,2,4,7,8,11,8,12,\n",
    "    11,13,13,16,17,18,17,19,21\n",
    "]).reshape(-1,1)\n",
    "Y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "8d228d3a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 学习率\n",
    "alpha = 0.01"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "44c9d0a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "optimal:  [[0.51583286]\n",
      " [0.96992163]]\n",
      "cost function:  1.0149624062331013\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 我们以矩阵向量的形式定义代价函数和代价函数的梯度\n",
    "'''\n",
    "theta:2 × 1\n",
    "X : 20 × 2\n",
    "Y : 20 × 1\n",
    "\n",
    "dot(X,theta): 20 × 1\n",
    "diff : 20 × 1\n",
    "\n",
    "(1/(2*m)) * dot(diff.transpose(),diff) : [[*]]----->所以取值要用 cost_function(theta,X,Y)[0][0]\n",
    "同理，(1/m) * dot(diff.transpose(),diff)\n",
    "\n",
    "'''\n",
    "# 代价函数\n",
    "def cost_function(theta,X,Y):\n",
    "    diff = dot(X,theta) - Y\n",
    "    return (1/(2*m)) * dot(diff.transpose(),diff)    # 求平方 \n",
    "\n",
    "# 定义代价函数对应的梯度函数-----微分后 2 与 1/2 抵消了\n",
    "def gradient_function(theta,X,Y):\n",
    "    diff = dot(X,theta) - Y\n",
    "    return (1/m) * dot(X.transpose(),diff)        # 求平方\n",
    "    \n",
    "    \n",
    "# 核心算法部分，梯度下降迭代方式\n",
    "# 梯度下降迭代\n",
    "def gradient_descent(X,Y,alpha):\n",
    "    theta = array([1,1]).reshape(2,1)\n",
    "    gradient = gradient_function(theta, X, Y)\n",
    "    # 当梯度小于 le-5 时，说明已进入比较平滑状态，可以退出循环\n",
    "    while not all(abs(gradient) <= 1e-5):\n",
    "        theta = theta - alpha * gradient\n",
    "        gradient = gradient_function(theta, X, Y)\n",
    "    return theta\n",
    "\n",
    "optimal = gradient_descent(X, Y, alpha)\n",
    "print('optimal: ',optimal)\n",
    "print('cost function: ',cost_function(optimal,X,Y)[0][0])\n",
    "\n",
    "\n",
    "# 根据数据画出对应图像\n",
    "def plot(X, Y, theta):\n",
    "    import matplotlib.pyplot as plt\n",
    "    ax = plt.subplot(111)\n",
    "    ax.scatter(X,Y,s = 30,c='blue')\n",
    "    plt.xlabel('X')\n",
    "    plt.ylabel('Y')\n",
    "    x = arange(0,21,0.2)\n",
    "    y = theta[0] + theta[1] * x\n",
    "    ax.plot(x,y)\n",
    "    plt.show()\n",
    "    \n",
    "plot(X1,Y,optimal)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e85f3807",
   "metadata": {},
   "source": [
    "**梯度下降策略对比**\n",
    "1. 批量梯度下降法——准确地朝着极值前进\n",
    "2. 随机梯度下降法——可能会收敛到局部最优\n",
    "3. 小批量梯度下降法——批量梯度下降法和随机梯度下降法的折中，对于m个样本采用x个样本来迭代，即若干个样本的平均梯度作为更新方向。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "103628cd",
   "metadata": {},
   "source": [
    "## 线性回归案例实战——房价预测线性回归模型（1）\n",
    "\n",
    "项目中使用数据集的三个字段解释如下：\n",
    "* RM : 房间数量。\n",
    "* LSTAT : 区域中被认为是低收入阶层的比例。\n",
    "* MEDV : 房屋的平均价格（目标特征，即我们所要预测的值）。\n",
    "\n",
    "        这个项目的最终目标是建立一个预测房屋价值的模型。\n",
    "\n",
    "我们需要把数据集分为 特征（Feature）和 目标变量（Target Variable）\n",
    "* 特征 : ‘RM’和‘LSTAT’,给我们提供了每个数据点的数量相关的信息。\n",
    "* 目标变量 : ‘MEDV’,是我们希望预测的变量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "62b01f91",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>CRIM</th>\n",
       "      <th>ZN</th>\n",
       "      <th>INDUS</th>\n",
       "      <th>CHAS</th>\n",
       "      <th>NOX</th>\n",
       "      <th>RM</th>\n",
       "      <th>AGE</th>\n",
       "      <th>DIS</th>\n",
       "      <th>RAD</th>\n",
       "      <th>TAX</th>\n",
       "      <th>PTRATIO</th>\n",
       "      <th>LSTAT</th>\n",
       "      <th>MEDV</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.00632</td>\n",
       "      <td>18.0</td>\n",
       "      <td>2.31</td>\n",
       "      <td>0</td>\n",
       "      <td>0.538</td>\n",
       "      <td>6.575</td>\n",
       "      <td>65.2</td>\n",
       "      <td>4.0900</td>\n",
       "      <td>1</td>\n",
       "      <td>296</td>\n",
       "      <td>15.3</td>\n",
       "      <td>4.98</td>\n",
       "      <td>24.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.02731</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.07</td>\n",
       "      <td>0</td>\n",
       "      <td>0.469</td>\n",
       "      <td>6.421</td>\n",
       "      <td>78.9</td>\n",
       "      <td>4.9671</td>\n",
       "      <td>2</td>\n",
       "      <td>242</td>\n",
       "      <td>17.8</td>\n",
       "      <td>9.14</td>\n",
       "      <td>21.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.02729</td>\n",
       "      <td>0.0</td>\n",
       "      <td>7.07</td>\n",
       "      <td>0</td>\n",
       "      <td>0.469</td>\n",
       "      <td>7.185</td>\n",
       "      <td>61.1</td>\n",
       "      <td>4.9671</td>\n",
       "      <td>2</td>\n",
       "      <td>242</td>\n",
       "      <td>17.8</td>\n",
       "      <td>4.03</td>\n",
       "      <td>34.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.03237</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.18</td>\n",
       "      <td>0</td>\n",
       "      <td>0.458</td>\n",
       "      <td>6.998</td>\n",
       "      <td>45.8</td>\n",
       "      <td>6.0622</td>\n",
       "      <td>3</td>\n",
       "      <td>222</td>\n",
       "      <td>18.7</td>\n",
       "      <td>2.94</td>\n",
       "      <td>33.4</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.06905</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2.18</td>\n",
       "      <td>0</td>\n",
       "      <td>0.458</td>\n",
       "      <td>7.147</td>\n",
       "      <td>54.2</td>\n",
       "      <td>6.0622</td>\n",
       "      <td>3</td>\n",
       "      <td>222</td>\n",
       "      <td>18.7</td>\n",
       "      <td>5.33</td>\n",
       "      <td>36.2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      CRIM   ZN   INDUS   CHAS    NOX     RM   AGE     DIS  RAD  TAX  PTRATIO  \\\n",
       "0  0.00632  18.0    2.31     0  0.538  6.575  65.2  4.0900    1  296     15.3   \n",
       "1  0.02731   0.0    7.07     0  0.469  6.421  78.9  4.9671    2  242     17.8   \n",
       "2  0.02729   0.0    7.07     0  0.469  7.185  61.1  4.9671    2  242     17.8   \n",
       "3  0.03237   0.0    2.18     0  0.458  6.998  45.8  6.0622    3  222     18.7   \n",
       "4  0.06905   0.0    2.18     0  0.458  7.147  54.2  6.0622    3  222     18.7   \n",
       "\n",
       "   LSTAT  MEDV  \n",
       "0   4.98  24.0  \n",
       "1   9.14  21.6  \n",
       "2   4.03  34.7  \n",
       "3   2.94  33.4  \n",
       "4   5.33  36.2  "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "# 读取数据\n",
    "df = pd.read_csv('data/boston.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "17b9543b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x432 with 12 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# seaborn 中 pairplot 函数可视化探索数据特征间的关系\n",
    "sns.set(context = 'notebook')\n",
    "# 绘制的散点图矩阵可以查看数据集内部特征之间的关系\n",
    "# 简单起见，只绘制三列（'LSTAT','RM','MEDV'（标记））特征和标记之间的联系\n",
    "cols = ['LSTAT','RM','MEDV']\n",
    "sns.pairplot(df[cols],height=2)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "2d569579",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x216 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,axes = plt.subplots(1,3,figsize=(8,3))\n",
    "plt.subplots_adjust(wspace=0.3,hspace=0.4)\n",
    "\n",
    "for i in range(len(cols)):\n",
    "    axes[i].hist(df[cols[i]],bins=20)\n",
    "    axes[i].set_xlabel(cols[i])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03b3deae",
   "metadata": {},
   "source": [
    "<img src='img/PAIRPLOT.png' width='400px' />"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d603b086",
   "metadata": {},
   "source": [
    "* 小结：\n",
    "    * 不难发现 MEDV 和 LSTAT存在反相关关系，MEDV 与 RM 存在正相关关系。\n",
    "    * 这里我们可以看出和波士顿房价相关性最强的两个因素，分别是 RM 和 LSTAT\n",
    "    \n",
    "    \n",
    "            还是具备一定逻辑的，首先房子越大自然价格更改，其次房东属于低收入群体也会使房价升高，这很好理解。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bbf102a",
   "metadata": {},
   "source": [
    "**调用sns.heatmap()方法绘制的关联矩阵可以看出特征之间的相关性大小**，关联矩阵是包含 皮尔森积矩相关系数 的正方形矩阵，用来度量 特征对 之间的线性依赖关系\n",
    "\n",
    "        皮尔森相关系数也称皮尔森积矩相关系数(Pearson product-moment correlation coefficient) ，是一种线性相关系数，是最常用的一种相关系数。记为r，用来反映两个变量X和Y的线性相关程度，r值介于-1到1之间，绝对值越大表明相关性越强。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "987103c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.        , -0.61380827, -0.73766273],\n",
       "       [-0.61380827,  1.        ,  0.69535995],\n",
       "       [-0.73766273,  0.69535995,  1.        ]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 可视化相关系数矩阵，理论：皮尔森相关系数\n",
    "cm = np.corrcoef(df[cols].values.T)\n",
    "cm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "99ce5558",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4.98 ,  6.575, 24.   ],\n",
       "       [ 9.14 ,  6.421, 21.6  ],\n",
       "       [ 4.03 ,  7.185, 34.7  ],\n",
       "       ...,\n",
       "       [ 5.64 ,  6.976, 23.9  ],\n",
       "       [ 6.48 ,  6.794, 22.   ],\n",
       "       [ 7.88 ,  6.03 , 11.9  ]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df[cols].values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "fb3d5868",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 将字体放大指定的倍数\n",
    "sns.set(font_scale=1.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "402ee1e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hm = sns.heatmap(cm\n",
    "                ,cbar=True\n",
    "                ,annot=True\n",
    "                ,square=True\n",
    "                ,fmt='.2f'\n",
    "                ,annot_kws = {'size':15}\n",
    "                ,yticklabels=cols\n",
    "                ,xticklabels=cols)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ed61a5b",
   "metadata": {},
   "source": [
    "**小结**：\n",
    "* 可以看出特征 LSTAT 和 MEDV 具有最高的相关性 -0.74，但是在散点图中会发现 LSTAT 和 MEDV 之间存在着非常明显的非线性相关\n",
    "\n",
    "\n",
    "* 特征 RM 和 标记 MEDV 也具有较高的相关性，并从散点矩阵中会发现特征 RM 和 标记 MEDV 之间存在着线性关系，因此接下来使用 RM 作为线性回归模型的特征"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "9d51ccab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Slope:9.102\n",
      "Intercept:-34.671\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "sk_model = LinearRegression()\n",
    "X = df[['RM']].values\n",
    "y = df['MEDV'].values\n",
    "\n",
    "sk_model.fit(X,y)\n",
    "print('Slope:%.3f'%sk_model.coef_[0])         # 斜率\n",
    "print('Intercept:%.3f'%sk_model.intercept_)   # 截距\n",
    "\n",
    "def Regression_plot(X,y,model):\n",
    "    plt.scatter(X,y,c='blue')\n",
    "    plt.plot(X,model.predict(X),c='red')\n",
    "    return None\n",
    "    \n",
    "Regression_plot(X,y,sk_model)\n",
    "plt.xlabel('RM')\n",
    "plt.ylabel('House price')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "c3ddf1f5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(506, 1)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "77b3e91f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(506,)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88d04da6",
   "metadata": {},
   "source": [
    "## 房价预测线性回归模型案例（2）\n",
    "数据集 ex1data2.txt 中的数据是两个特征，做一个简单的多元（此处为二元）线性回归。\n",
    "所有的样本都用来训练和预测。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "b2e5ca67",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from sklearn.metrics import mean_squared_error,r2_score\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "%matplotlib notebook"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "ce79acfd",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rcParams['font.sans-serif'] = ['SimHei']\n",
    "plt.rcParams['axes.unicode_minus'] = False\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "1b3f302b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据格式： 城市人口、房间人数、房价\n",
    "\n",
    "# 读取数据\n",
    "data = np.loadtxt('data/ex1data2.txt',encoding='gbk',delimiter=',')\n",
    "data_X = data[:,0:2]\n",
    "data_y = data[:,2]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "46da0881",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练模型\n",
    "sk_model = LinearRegression()\n",
    "sk_model.fit(data_X,data_y)\n",
    "\n",
    "# 模型预测\n",
    "y_predict = sk_model.predict(data_X)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "874fb3e2",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "/* global mpl */\n",
       "window.mpl = {};\n",
       "\n",
       "mpl.get_websocket_type = function () {\n",
       "    if (typeof WebSocket !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof MozWebSocket !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert(\n",
       "            'Your browser does not have WebSocket support. ' +\n",
       "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "                'Firefox 4 and 5 are also supported but you ' +\n",
       "                'have to enable WebSockets in about:config.'\n",
       "        );\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = this.ws.binaryType !== undefined;\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById('mpl-warnings');\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent =\n",
       "                'This browser does not support binary websocket messages. ' +\n",
       "                'Performance may be slow.';\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = document.createElement('div');\n",
       "    this.root.setAttribute('style', 'display: inline-block');\n",
       "    this._root_extra_style(this.root);\n",
       "\n",
       "    parent_element.appendChild(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen = function () {\n",
       "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
       "        fig.send_message('send_image_mode', {});\n",
       "        if (fig.ratio !== 1) {\n",
       "            fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n",
       "        }\n",
       "        fig.send_message('refresh', {});\n",
       "    };\n",
       "\n",
       "    this.imageObj.onload = function () {\n",
       "        if (fig.image_mode === 'full') {\n",
       "            // Full images could contain transparency (where diff images\n",
       "            // almost always do), so we need to clear the canvas so that\n",
       "            // there is no ghosting.\n",
       "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "        }\n",
       "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "    };\n",
       "\n",
       "    this.imageObj.onunload = function () {\n",
       "        fig.ws.close();\n",
       "    };\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_header = function () {\n",
       "    var titlebar = document.createElement('div');\n",
       "    titlebar.classList =\n",
       "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
       "    var titletext = document.createElement('div');\n",
       "    titletext.classList = 'ui-dialog-title';\n",
       "    titletext.setAttribute(\n",
       "        'style',\n",
       "        'width: 100%; text-align: center; padding: 3px;'\n",
       "    );\n",
       "    titlebar.appendChild(titletext);\n",
       "    this.root.appendChild(titlebar);\n",
       "    this.header = titletext;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
       "    canvas_div.setAttribute(\n",
       "        'style',\n",
       "        'border: 1px solid #ddd;' +\n",
       "            'box-sizing: content-box;' +\n",
       "            'clear: both;' +\n",
       "            'min-height: 1px;' +\n",
       "            'min-width: 1px;' +\n",
       "            'outline: 0;' +\n",
       "            'overflow: hidden;' +\n",
       "            'position: relative;' +\n",
       "            'resize: both;'\n",
       "    );\n",
       "\n",
       "    function on_keyboard_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.key_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    canvas_div.addEventListener(\n",
       "        'keydown',\n",
       "        on_keyboard_event_closure('key_press')\n",
       "    );\n",
       "    canvas_div.addEventListener(\n",
       "        'keyup',\n",
       "        on_keyboard_event_closure('key_release')\n",
       "    );\n",
       "\n",
       "    this._canvas_extra_style(canvas_div);\n",
       "    this.root.appendChild(canvas_div);\n",
       "\n",
       "    var canvas = (this.canvas = document.createElement('canvas'));\n",
       "    canvas.classList.add('mpl-canvas');\n",
       "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
       "\n",
       "    this.context = canvas.getContext('2d');\n",
       "\n",
       "    var backingStore =\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        this.context.webkitBackingStorePixelRatio ||\n",
       "        this.context.mozBackingStorePixelRatio ||\n",
       "        this.context.msBackingStorePixelRatio ||\n",
       "        this.context.oBackingStorePixelRatio ||\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        1;\n",
       "\n",
       "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
       "        'canvas'\n",
       "    ));\n",
       "    rubberband_canvas.setAttribute(\n",
       "        'style',\n",
       "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
       "    );\n",
       "\n",
       "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
       "    if (this.ResizeObserver === undefined) {\n",
       "        if (window.ResizeObserver !== undefined) {\n",
       "            this.ResizeObserver = window.ResizeObserver;\n",
       "        } else {\n",
       "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
       "            this.ResizeObserver = obs.ResizeObserver;\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
       "        var nentries = entries.length;\n",
       "        for (var i = 0; i < nentries; i++) {\n",
       "            var entry = entries[i];\n",
       "            var width, height;\n",
       "            if (entry.contentBoxSize) {\n",
       "                if (entry.contentBoxSize instanceof Array) {\n",
       "                    // Chrome 84 implements new version of spec.\n",
       "                    width = entry.contentBoxSize[0].inlineSize;\n",
       "                    height = entry.contentBoxSize[0].blockSize;\n",
       "                } else {\n",
       "                    // Firefox implements old version of spec.\n",
       "                    width = entry.contentBoxSize.inlineSize;\n",
       "                    height = entry.contentBoxSize.blockSize;\n",
       "                }\n",
       "            } else {\n",
       "                // Chrome <84 implements even older version of spec.\n",
       "                width = entry.contentRect.width;\n",
       "                height = entry.contentRect.height;\n",
       "            }\n",
       "\n",
       "            // Keep the size of the canvas and rubber band canvas in sync with\n",
       "            // the canvas container.\n",
       "            if (entry.devicePixelContentBoxSize) {\n",
       "                // Chrome 84 implements new version of spec.\n",
       "                canvas.setAttribute(\n",
       "                    'width',\n",
       "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
       "                );\n",
       "                canvas.setAttribute(\n",
       "                    'height',\n",
       "                    entry.devicePixelContentBoxSize[0].blockSize\n",
       "                );\n",
       "            } else {\n",
       "                canvas.setAttribute('width', width * fig.ratio);\n",
       "                canvas.setAttribute('height', height * fig.ratio);\n",
       "            }\n",
       "            canvas.setAttribute(\n",
       "                'style',\n",
       "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
       "            );\n",
       "\n",
       "            rubberband_canvas.setAttribute('width', width);\n",
       "            rubberband_canvas.setAttribute('height', height);\n",
       "\n",
       "            // And update the size in Python. We ignore the initial 0/0 size\n",
       "            // that occurs as the element is placed into the DOM, which should\n",
       "            // otherwise not happen due to the minimum size styling.\n",
       "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
       "                fig.request_resize(width, height);\n",
       "            }\n",
       "        }\n",
       "    });\n",
       "    this.resizeObserverInstance.observe(canvas_div);\n",
       "\n",
       "    function on_mouse_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.mouse_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousedown',\n",
       "        on_mouse_event_closure('button_press')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseup',\n",
       "        on_mouse_event_closure('button_release')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'dblclick',\n",
       "        on_mouse_event_closure('dblclick')\n",
       "    );\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousemove',\n",
       "        on_mouse_event_closure('motion_notify')\n",
       "    );\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseenter',\n",
       "        on_mouse_event_closure('figure_enter')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseleave',\n",
       "        on_mouse_event_closure('figure_leave')\n",
       "    );\n",
       "\n",
       "    canvas_div.addEventListener('wheel', function (event) {\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        on_mouse_event_closure('scroll')(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.appendChild(canvas);\n",
       "    canvas_div.appendChild(rubberband_canvas);\n",
       "\n",
       "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
       "    this.rubberband_context.strokeStyle = '#000000';\n",
       "\n",
       "    this._resize_canvas = function (width, height, forward) {\n",
       "        if (forward) {\n",
       "            canvas_div.style.width = width + 'px';\n",
       "            canvas_div.style.height = height + 'px';\n",
       "        }\n",
       "    };\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
       "        event.preventDefault();\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus() {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'mpl-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'mpl-button-group';\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'mpl-button-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        var button = (fig.buttons[name] = document.createElement('button'));\n",
       "        button.classList = 'mpl-widget';\n",
       "        button.setAttribute('role', 'button');\n",
       "        button.setAttribute('aria-disabled', 'false');\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "\n",
       "        var icon_img = document.createElement('img');\n",
       "        icon_img.src = '_images/' + image + '.png';\n",
       "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
       "        icon_img.alt = tooltip;\n",
       "        button.appendChild(icon_img);\n",
       "\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    var fmt_picker = document.createElement('select');\n",
       "    fmt_picker.classList = 'mpl-widget';\n",
       "    toolbar.appendChild(fmt_picker);\n",
       "    this.format_dropdown = fmt_picker;\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = document.createElement('option');\n",
       "        option.selected = fmt === mpl.default_extension;\n",
       "        option.innerHTML = fmt;\n",
       "        fmt_picker.appendChild(option);\n",
       "    }\n",
       "\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.send_message = function (type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function () {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
       "        fig.send_message('refresh', {});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
       "    var x0 = msg['x0'] / fig.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
       "    var x1 = msg['x1'] / fig.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0,\n",
       "        0,\n",
       "        fig.canvas.width / fig.ratio,\n",
       "        fig.canvas.height / fig.ratio\n",
       "    );\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch (cursor) {\n",
       "        case 0:\n",
       "            cursor = 'pointer';\n",
       "            break;\n",
       "        case 1:\n",
       "            cursor = 'default';\n",
       "            break;\n",
       "        case 2:\n",
       "            cursor = 'crosshair';\n",
       "            break;\n",
       "        case 3:\n",
       "            cursor = 'move';\n",
       "            break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
       "    for (var key in msg) {\n",
       "        if (!(key in fig.buttons)) {\n",
       "            continue;\n",
       "        }\n",
       "        fig.buttons[key].disabled = !msg[key];\n",
       "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
       "    if (msg['mode'] === 'PAN') {\n",
       "        fig.buttons['Pan'].classList.add('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    } else if (msg['mode'] === 'ZOOM') {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.add('active');\n",
       "    } else {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message('ack', {});\n",
       "};\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            var img = evt.data;\n",
       "            if (img.type !== 'image/png') {\n",
       "                /* FIXME: We get \"Resource interpreted as Image but\n",
       "                 * transferred with MIME type text/plain:\" errors on\n",
       "                 * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "                 * to be part of the websocket stream */\n",
       "                img.type = 'image/png';\n",
       "            }\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src\n",
       "                );\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                img\n",
       "            );\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        } else if (\n",
       "            typeof evt.data === 'string' &&\n",
       "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
       "        ) {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig['handle_' + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\n",
       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
       "                msg\n",
       "            );\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\n",
       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
       "                    e,\n",
       "                    e.stack,\n",
       "                    msg\n",
       "                );\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "};\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function (e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e) {\n",
       "        e = window.event;\n",
       "    }\n",
       "    if (e.target) {\n",
       "        targ = e.target;\n",
       "    } else if (e.srcElement) {\n",
       "        targ = e.srcElement;\n",
       "    }\n",
       "    if (targ.nodeType === 3) {\n",
       "        // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "    }\n",
       "\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    var boundingRect = targ.getBoundingClientRect();\n",
       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
       "\n",
       "    return { x: x, y: y };\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys(original) {\n",
       "    return Object.keys(original).reduce(function (obj, key) {\n",
       "        if (typeof original[key] !== 'object') {\n",
       "            obj[key] = original[key];\n",
       "        }\n",
       "        return obj;\n",
       "    }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function (event, name) {\n",
       "    var canvas_pos = mpl.findpos(event);\n",
       "\n",
       "    if (name === 'button_press') {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * this.ratio;\n",
       "    var y = canvas_pos.y * this.ratio;\n",
       "\n",
       "    this.send_message(name, {\n",
       "        x: x,\n",
       "        y: y,\n",
       "        button: event.button,\n",
       "        step: event.step,\n",
       "        guiEvent: simpleKeys(event),\n",
       "    });\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.key_event = function (event, name) {\n",
       "    // Prevent repeat events\n",
       "    if (name === 'key_press') {\n",
       "        if (event.key === this._key) {\n",
       "            return;\n",
       "        } else {\n",
       "            this._key = event.key;\n",
       "        }\n",
       "    }\n",
       "    if (name === 'key_release') {\n",
       "        this._key = null;\n",
       "    }\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.key !== 'Control') {\n",
       "        value += 'ctrl+';\n",
       "    }\n",
       "    else if (event.altKey && event.key !== 'Alt') {\n",
       "        value += 'alt+';\n",
       "    }\n",
       "    else if (event.shiftKey && event.key !== 'Shift') {\n",
       "        value += 'shift+';\n",
       "    }\n",
       "\n",
       "    value += 'k' + event.key;\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
       "    if (name === 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message('toolbar_button', { name: name });\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "\n",
       "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
       "// prettier-ignore\n",
       "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";/* global mpl */\n",
       "\n",
       "var comm_websocket_adapter = function (comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.binaryType = comm.kernel.ws.binaryType;\n",
       "    ws.readyState = comm.kernel.ws.readyState;\n",
       "    function updateReadyState(_event) {\n",
       "        if (comm.kernel.ws) {\n",
       "            ws.readyState = comm.kernel.ws.readyState;\n",
       "        } else {\n",
       "            ws.readyState = 3; // Closed state.\n",
       "        }\n",
       "    }\n",
       "    comm.kernel.ws.addEventListener('open', updateReadyState);\n",
       "    comm.kernel.ws.addEventListener('close', updateReadyState);\n",
       "    comm.kernel.ws.addEventListener('error', updateReadyState);\n",
       "\n",
       "    ws.close = function () {\n",
       "        comm.close();\n",
       "    };\n",
       "    ws.send = function (m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function (msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        var data = msg['content']['data'];\n",
       "        if (data['blob'] !== undefined) {\n",
       "            data = {\n",
       "                data: new Blob(msg['buffers'], { type: data['blob'] }),\n",
       "            };\n",
       "        }\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(data);\n",
       "    });\n",
       "    return ws;\n",
       "};\n",
       "\n",
       "mpl.mpl_figure_comm = function (comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = document.getElementById(id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm);\n",
       "\n",
       "    function ondownload(figure, _format) {\n",
       "        window.open(figure.canvas.toDataURL());\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element;\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error('Failed to find cell for figure', id, fig);\n",
       "        return;\n",
       "    }\n",
       "    fig.cell_info[0].output_area.element.on(\n",
       "        'cleared',\n",
       "        { fig: fig },\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
       "    var width = fig.canvas.width / fig.ratio;\n",
       "    fig.cell_info[0].output_area.element.off(\n",
       "        'cleared',\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable();\n",
       "    fig.parent_element.innerHTML =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "    fig.close_ws(fig, msg);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width / this.ratio;\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message('ack', {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () {\n",
       "        fig.push_to_output();\n",
       "    }, 1000);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'btn-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'btn-group';\n",
       "    var button;\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'btn-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        button = fig.buttons[name] = document.createElement('button');\n",
       "        button.classList = 'btn btn-default';\n",
       "        button.href = '#';\n",
       "        button.title = name;\n",
       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message pull-right';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = document.createElement('div');\n",
       "    buttongrp.classList = 'btn-group inline pull-right';\n",
       "    button = document.createElement('button');\n",
       "    button.classList = 'btn btn-mini btn-primary';\n",
       "    button.href = '#';\n",
       "    button.title = 'Stop Interaction';\n",
       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
       "    button.addEventListener('click', function (_evt) {\n",
       "        fig.handle_close(fig, {});\n",
       "    });\n",
       "    button.addEventListener(\n",
       "        'mouseover',\n",
       "        on_mouseover_closure('Stop Interaction')\n",
       "    );\n",
       "    buttongrp.appendChild(button);\n",
       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
       "    var fig = event.data.fig;\n",
       "    if (event.target !== this) {\n",
       "        // Ignore bubbled events from children.\n",
       "        return;\n",
       "    }\n",
       "    fig.close_ws(fig, {});\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (el) {\n",
       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
       "    // this is important to make the div 'focusable\n",
       "    el.setAttribute('tabindex', 0);\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    } else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager) {\n",
       "        manager = IPython.keyboard_manager;\n",
       "    }\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which === 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "};\n",
       "\n",
       "mpl.find_output_cell = function (html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i = 0; i < ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code') {\n",
       "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] === html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "};\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel !== null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target(\n",
       "        'matplotlib',\n",
       "        mpl.mpl_figure_comm\n",
       "    );\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"\" width=\"856.8\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0.92, '线性回归——城市人口、房间人数和房价的关系')"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 可视化\n",
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "ax.scatter(data_X[:,0],data_X[:,1],data_y,color='red')\n",
    "ax.plot(data_X[:,0],data_X[:,1],y_predict,color='blue')\n",
    "\n",
    "ax.set_xlabel('城市人口')\n",
    "ax.set_ylabel('房间人数')\n",
    "ax.set_zlabel('房价')\n",
    "plt.title('线性回归——城市人口、房间人数和房价的关系')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "77c1d1da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "model.coef_:  [  139.21067402 -8738.01911233]\n",
      "model.intercept_:  89597.90954279754\n",
      "MSE_均方误差: 4086560101.2056575\n",
      "R^2_ 0.7329450180289142\n"
     ]
    }
   ],
   "source": [
    "# 模型参数\n",
    "print('model.coef_: ',model.coef_)\n",
    "print('model.intercept_: ',model.intercept_)\n",
    "\n",
    "# MSE_均方误差\n",
    "print('MSE_均方误差:',mean_squared_error(data_y,y_predict))\n",
    "# R^2_\n",
    "print('R^2_',r2_score(data_y,y_predict))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "c4a29a97",
   "metadata": {},
   "outputs": [],
   "source": [
    "# plt.figure(figsize=(3, 3))\n",
    "# ax3d = plt.gca(projection=\"3d\")  # 创建三维坐标\n",
    "# ax3d.set_xlim(40,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce7cd6cb",
   "metadata": {},
   "source": [
    "# 2.逻辑回归 Logistic\n",
    "\n",
    "\n",
    "#### 1. 逻辑回归和线性回归\n",
    "\n",
    "        尽管名字中有“回归”二字，但是它不是一个需要预测连续结果的回归算法。\n",
    "* 逻辑回归得到一个离散的结果\n",
    "\n",
    "        逻辑回归的结果总是一件事（患者有癌症）或是另一个（患者没有癌症）。\n",
    "        逻辑回归是二分类任务的首选方法。\n",
    "        它输出一个 0-1 之间的离散二值结果。\n",
    "    * **简单来说它的结果不是 0 就是 1**\n",
    "        \n",
    "* 线性回归得到一个连续的结果\n",
    "        \n",
    "        预测房价的模型算是返回连续结果的一个例子。\n",
    "        该值随着房子大小或位置等参数的变化而变化。\n",
    "      \n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8d1cb2e",
   "metadata": {},
   "source": [
    "#### 2. 逻辑回归基本的知识点\n",
    "     逻辑回归实际上是一种分类方法，主要用于二分类问题（即输出只有两种，分别代表两个类）。\n",
    "                \n",
    "     所以利用了逻辑函数（或称为 Sigmoid 函数）估计概率，来衡量因变量（我们想要预测的标签）与一个或多个自变量（特征）之间的关系。\n",
    "                \n",
    "     这些概率必须二值化才能真正地进行预测。\n",
    "\n",
    "<img src='img/sigmoid.jpg' width='400px'/>\n",
    "y = g(z) 在 z = 0 时取值为 1/2 ， 而随着 z 逐渐变小，函数值趋于 0 ，z 逐渐变大的同时函数值逐渐趋于 1，这正是概率的范围。\n",
    "\n",
    "一个 S 形曲线，它可以将任意实数映射到介于 0 和 1 之间的值，但并不会取到 0/1，然后使用阈值分类器将 0 和 1 之间的值转换为 0 或 1。\n",
    "\n",
    "逻辑回归得出预测所需要的步骤：\n",
    "<img src='img/逻辑回归步骤.jpg' width='400px'/>\n",
    "\n",
    "#### 适用条件\n",
    "**数据是线性可分的。** 换句话说，当 Y 变量只有两个值时（例如，当面临分类问题时），我们应该考虑逻辑回归。\n",
    "\n",
    "            逻辑回归的一大优点是它非常容易实现，且训练起来很高效。\n",
    "            在研究中，我们通常以逻辑回归模型作为基准，再尝试更复杂的算法。\n",
    "            \n",
    "            逻辑回顾并非最强大的算法之一，它可以很容易被更为复杂的算法所超越。\n",
    "            另一个缺点是它高度依赖正确的数据表示。\n",
    "            另外，逻辑回归同时以其容易过拟合而闻名。\n",
    "\n",
    "<img src='img/线性可分.jpg' width='250px'/>        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1cede130",
   "metadata": {},
   "source": [
    "## 逻辑回归案例实战\n",
    "<img src='img/逻辑回归实战.jpg' width='400px'/> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "42e18089",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Intercept: [-0.01205336]\n",
      "Coef [[ 0.00610607 -0.73416787]]\n",
      "款项是否可以立刻到账？ 1\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LogisticRegression\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "x_data = [\n",
    "    [6000, 58],\n",
    "    [9000, 77],\n",
    "    [11000, 89],\n",
    "    [15000, 54]\n",
    "]\n",
    "\n",
    "y_data = [\n",
    "    0,0,1,1\n",
    "]\n",
    "\n",
    "lr = LogisticRegression()\n",
    "lr.fit(x_data,y_data)\n",
    "x_test = [[12000,60]]\n",
    "print('Intercept:',lr.intercept_)\n",
    "print('Coef',lr.coef_)\n",
    "\n",
    "# 返回结果是按列排序的，取第一个就要加上【0】\n",
    "print('款项是否可以立刻到账？',lr.predict(x_test)[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6f7a294",
   "metadata": {},
   "source": [
    "# 回归算法总结"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb75a86e",
   "metadata": {},
   "source": [
    "【优点】\n",
    "1. 思想简单，容易实现没建模迅速，对于小数据量，简单的关系很有效。\n",
    "        \n",
    "        由于其简单可快速实现的原因，因此可以用它来衡量其他更为复杂算法的性能。\n",
    "\n",
    "2. 是许多强大的非线性模型的基础。\n",
    "\n",
    "3. 线性回归模型十分容易理解，结果具有很好的可解释性，有利于决策分析\n",
    "\n",
    "4. 蕴含机器学习中的很多重要思想\n",
    "\n",
    "【缺点】\n",
    "1. 对于 非线性数据 或 数据特征间有相关性的多项式回归，难以建模。\n",
    "        \n",
    "        我们不能用逻辑回归来解决非线性问题，因为它的决策面试线性的。\n",
    "        \n",
    "2. 难以很好地表达高度复杂的数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "706d1add",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "056fcf8b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e3638a3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "470f01be",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f6fe3fd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f3015b23",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
